# list列表
# name_list = ['itheima','itcast','python']
# print(name_list)
# print(type(name_list))
# print(name_list[0])
# print(name_list[1])
# print(name_list[2])
# index = name_list.index('itheima')
# print(index)
# list 列表不区别类型数据
# name_list = ['itheima',666,True]
# print(name_list)
# print(type(name_list))
# print(name_list[0])
# name_list[1] = 8888
# name_list.insert(2,'插入的值')
# print(name_list[1])
# print(name_list[2])
# print(name_list)
# 嵌套列表
# my_list = [[1,2,3],[4,5,6]]
# print(my_list)
# print(type(my_list))
# print(my_list[0][0])
# print(my_list[-1][-2])
# 追加列表的值
# my_list = [1,2,3]
# my_list2 = [1,2,3]
# print(my_list)
# print(my_list2)
# my_list.append(6)
# my_list2.append([4,5,6])
# print(my_list)
# print(my_list2)
# 追加列表的值2
# my_list = [1,2,3]
# my_list.extend([4,5,6])
# print(my_list)
# 删除列表方式一和二
# my_list = [1,2,3]
# del my_list[0]
# print(my_list)
# del_value = my_list.pop(0)
# print(del_value)
# print(my_list)

# 删除列表指定匹配的第一个元素的值

# name_list = ['itcast','itheima','python','itheima','c++','itheima']
# name_list.remove('itheima')
#
# print(name_list)
# # 清空列表功能
# name_list.clear()
# print(name_list)

# 统计功能
# my_list = [1,2,1,3,5,1]
# print(my_list.count(1))
# # 统计列表元素数量
# print(len(my_list))

# my_list = [21, 25, 21, 23, 22, 20]
# print(my_list)
# my_list.append(31)
# print(my_list)
# my_list.extend([29,33,30])
# print(my_list)
# my_list[0]
# print(my_list[0])
# my_list[-1]
# print(my_list[-1])
#
# print(my_list.index(31))
# print(my_list)
#
# # 遍历元素
# index = 0
# while index < len(my_list):
#     ys = my_list[index]
#     print(ys)
#     index += 1

# def list_for_func():
#     my_list = [21, 25, 21, 23, 22, 20]
#     for i in my_list:
#         print(i)
#
# list_for_func()

# 元组
# t1 = tuple(1,2,True,'yes')
# t2 = (1,2,True,'yes')
# print(t1)
# print(type(t1))
# 注意定义当个元组的时候带，号
# 错误示范
# t1 = ('1')
# print(type(t1))
# # 正确示范
# t2 = ('1',)
# print(type(t2))
# 下标取出内容
# t1 = (1,2,True,'yes')
# print(t1[3])
# t1 = ((1,2,True,'yes'),(1,2,True,'yes'))
# print(t1[0][1])
# t1 = (1,(1,2,True,'yes'))
# print(t1[1][0])
# 元组中 index ，count，len操作
#index 查找第一个匹配项
# t1 = (1,2,'yes',1,2,'yes')
# print(t1.index('yes'))
# #count 统计某个元素出现的次数
# t1 = (1,2,'yes',1,2,'yes')
# print(t1.count('yes'))
# #len操作 统计元组的长度
# t1 = (1,2,'yes',1,2,'yes')
# print(len(t1))
# # 元组的遍历：while
# index = 0
# while index < len(t1):
#     print(f"元组中的元素有：{t1[index]}")
#     index +=1
# # 元组的遍历：for
# for index in t1:
#     print(f"2元组中的元素有：{index}")
# 错误示范：尝试修改元组中的元素
# t1 = (1,2,'yes',1,2,'yes')
# t1[0] = 2
# 正确示范：只能修改元组中list的元素
# t1 = (1,2,['itheima','hello'])
# t1[2][0] = 'yesyes'
# print(t1)

# t1 = ('周杰轮',11, ['football', 'music'])
# print(t1.index(11))
# print(t1[0])
# del t1[2][0]
# print(t1)
# t1[2].remove('music')
# print(t1)
# t1[2].append('hello')
# print(t1)

# my_str = "itheima and itcast"
# # 下标索引取值
# value = my_str[2]
# value2 = my_str[-2]
# print(f"value的值是：{value} value2的值是：{value2}")
# #index方法 获取下标
# value = my_str.index("and")
# print(f"在字符串{my_str}中and的下标是：{value}")
# # replace方法替换
# value = my_str.replace("it","程序")
# print(value)
# # split
# my_str = "hello python itheima itcast"
# my_str_list = my_str.strip(" ")
# print(f"将字符串{my_str}进行split切分后得到：{my_str_list}, 类型是：{type(my_str_list)}")
# # strip方法 去除空格或者指定值
# my_str = " itheima and itcaast"
# new_my_str = my_str.strip() # 不传入参数，去除首尾空格
# print(f"字符串{my_str}被strip后，结果：{new_my_str}")
#
# my_str = "12itheima and itcast21"
# new_my_str = my_str.strip("12")
# print(f"字符串{my_str}被strip('12')后，结果：{new_my_str}")
# # 统计字符串中某字符串的出现次数, count
# my_str = "itheima and itcast"
# count = my_str.count("it")
# print(f"字符串{my_str}中it出现的次数是：{count}")
# # 统计字符串的长度, len()
# num = len(my_str)
# print(f"字符串{my_str}的长度是：{num}")


# 练习
# my_str = "itheima itcast boxuegu"
#
# count = my_str.count("it")
# print(count)
# new_my_str = my_str.replace(" ","|")
# print(new_my_str)
# new_my_str2 = new_my_str.split("|")
# print(new_my_str2)


# 序列和切片操作
# 对list列表进行切片，从1开始，4结束，步长1
# my_list = [0, 1, 2, 3, 4, 5, 6]
# result1 = my_list[1:4] # 步长默认为1可以省略
# print(f"结果2：{result1}")
# # 对tuple元组进行切片，从头开始，到最后结束，步长1
# my_tuple = (0, 1, 2, 3, 4, 5, 6)
# result2 = my_tuple[:]  # 步长默认为1可以省略
# print(f"结果2：{result2}")
#
# # 对str进行切片，从头开始，到最后结束，步长2
# my_str = "01234567"
# result3 = my_str[::2]
# print(f"结果4：{result3}")
#
# # 对str进行切片，从头开始，到最后结束，步长-1
# my_str = "01234567"
# result4 = my_str[::-1]  # 等同于将序列反转了
# print(f"结果4：{result4}")
#
# # 对列表进行切片，从3开始，到1结束，步长-1
# my_list = [0, 1, 2, 3, 4, 5, 6]
# result5 = my_list[3:1:-1]
# print(f"结果5：{result5}")
#
# # 对元组进行切片，从头开始，到尾结束，步长-2
# my_tuple = (0, 1, 2, 3, 4, 5, 6)
# result6 = my_tuple[::-2] # 负数都是直接从尾巴往前面切
# print(f"结果6：{result6}")

# my_list = ["万过薪月", "员序程马黑来", "nohtyP学"]
# list = my_list[1]
# print(type(list))
# result = list[-2::-1]
# print(result)
# my_str = "万过薪月,员序程马黑来,nohtyP学"
# result2 = my_str[::-1][9:14:]
# print(result2)
# result3 = my_str.split(",")[1][-2::-1]
# print(result3)

# 定义集合
# my_set = {"hello", "world","传智教育", "黑马程序员", "itheima"}
# my_set_empty = set() # 定义空集合
#
# # 添加新元素
# my_set.add("python")
# my_set.add("小何教育")
# print(f"my_set添加元素后结果是：{my_set}")
# # 移除元素
# my_set.remove("黑马程序员")
# print(f"my_set移除黑马程序员后，结果是：{my_set}")
# # 随机取出一个元素
# my_set = {"传智教育", "黑马程序员", "itheima"}
# element = my_set.pop()
# print(f"集合被取出元素是：{element}, 取出元素后：{my_set}")
#
# # 清空集合，clear
# my_set.clear()
# print(f"集合被清空啦，结果是：{my_set}")
#
# # 取两个集合的差集
# set1 = {1, 2, 3}
# set2 = {1, 5, 6}
# set3 = set1.difference(set2)
# print(f"取出差集后的结果是：{set3}")
# print(f"取差集后，原有set1的内容：{set1}")
# print(f"取差集后，原有set2的内容：{set2}")
#
# # 消除2个集合的差集
# set1 = {1, 2, 3}
# set2 = {1, 5, 6}
# set1.difference_update(set2)
# print(f"消除差集后，集合1结果：{set1}")
# print(f"消除差集后，集合2结果：{set2}")
# # 2个集合合并为1个
# set1 = {1, 2, 3}
# set2 = {1, 5, 6}
# set3 = set1.union(set2)
# print(f"2集合合并结果：{set3}")
# print(f"合并后集合1：{set1}")
# print(f"合并后集合2：{set2}")
# # 统计集合元素数量len()
# set1 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
# num = len(set1)
# print(f"集合内的元素数量有：{num}个")

# 集合的遍历
# 集合不支持下标索引，不能用while循环
# 可以用for循环
# set1 = {1, 2, 3, 4, 5}
# for element in set1:
#     print(f"集合的元素有：{element}")

# my_list = ['黑马程序员', '传智播客', '黑马程序员', '传智播客',
#     'itheima', 'itcast', 'itheima', 'itcast', 'best']
# # 定义一个空集合
# my_set = set()
# # 通过for循环遍历列表
# for element in my_list:
#     # 在for循环中将列表的元素添加至集合
#     my_set.add(element)
#
# # 最终得到元素去重后的集合对象，并打印输出
# print(f"列表的内容是：{my_list}")
# print(f"通过for循环后，得到的集合对象是：{my_set}")


# """
# 演示数据容器字典的定义
# """

# 定义字典
# my_dict1 = {"王力鸿":99, "周杰轮":88,"林俊杰":77}
# # 定义空字典
# my_dict2 = {}
# my_dict3 = dict()
# print(f"字典1的内容是：{my_dict1}, 类型：{type(my_dict1)}")
# print(f"字典2的内容是：{my_dict2}, 类型：{type(my_dict2)}")
# print(f"字典3的内容是：{my_dict3}, 类型：{type(my_dict3)}")
#
# # 定义重复Key的字典
# my_dict1 = {"王力鸿": 99, "王力鸿": 88, "林俊节": 77}
# print(f"重复key的字典的内容是：{my_dict1}")
# # 从字典中基于Key获取Value
# my_dict1 = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77}
# score = my_dict1["王力鸿"]
# print(f"王力鸿的考试分数是：{score}")
# score = my_dict1["周杰轮"]
# print(f"周杰轮的考试分数是：{score}")
# # 定义嵌套字典
# stu_score_dict = {
#     "王力鸿": {
#         "语文": 77,
#         "数学": 66,
#         "英语": 33
#     }, "周杰轮": {
#         "语文": 88,
#         "数学": 86,
#         "英语": 55
#     }, "林俊节": {
#         "语文": 99,
#         "数学": 96,
#         "英语": 66
#     }
# }
# print(f"学生的考试信息是：{stu_score_dict}")
# new_dict = stu_score_dict["王力鸿"]["语文"]
# print(new_dict)
# # 从嵌套字典中获取数据
# # 看一下周杰轮的语文信息
# score = stu_score_dict["周杰轮"]["语文"]
# print(f"周杰轮的语文分数是：{score}")
# score = stu_score_dict["林俊节"]["英语"]
# print(f"林俊节的英语分数是：{score}")

# """
# 演示字典的常用操作
# """
# my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
# # 新增元素
# my_dict["张信哲"] = 66
# print(f"字典经过新增元素后，结果：{my_dict}")
# # 更新元素
# my_dict["周杰轮"] = 33
# print(f"字典经过更新后，结果：{my_dict}")
# score = my_dict.pop("周杰轮")
# print(f"字典中被移除了一个元素，结果：{my_dict}, 周杰轮的考试分数是：{score}")
#
# # 清空元素
# my_dict.clear()
# print(f"字典被清空了，内容是：{my_dict}")
# # 获取全部的可以
# my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
# keys = my_dict.keys()
# print(f"字典的全部keys是：{keys}")
# # 遍历字典
# # 方式1：通过获取到全部的key来完成遍历
# for key in keys:
#     print(f"字典的key是:{key}")
#     print(f"字典的value是：{my_dict[key]}")
#
# # 方式2：直接对字典进行for循环，每一次循环都是直接得到key
# for key in my_dict:
#     print(f"2字典的key是：{key}")
#     print(f"2字典的value是：{my_dict[key]}")
# # 统计字典内的元素数量, len()函数
# num = len(my_dict)
# print(f"字典中的元素数量有：{num}个")

# """
# 演示字典的课后练习：升职加薪，对所有级别为1级的员工，级别上升1级，薪水增加1000元
# """
#
# # 组织字典记录数据
# info_dict = {
#     "王力鸿": {
#         "部门": "科技部",
#         "工资": 3000,
#         "级别": 1
#     },
#     "周杰轮": {
#         "部门": "市场部",
#         "工资": 5000,
#         "级别": 2
#     },
#     "林俊节": {
#         "部门": "市场部",
#         "工资": 7000,
#         "级别": 3
#     },
#     "张学油": {
#         "部门": "科技部",
#         "工资": 4000,
#         "级别": 1
#     },
#     "刘德滑": {
#         "部门": "市场部",
#         "工资": 6000,
#         "级别": 2
#     }
# }
#
# print(f"员工在升值加薪之前的结果：{info_dict}")
#
# for name in info_dict:
#     # if条件判断员工是否符合条件
#     if info_dict[name]["级别"] == 1:
#         # 加薪操作
#         # 获取员工的信息字典
#         employee_info_dist = info_dict[name]
#         # 修改员工信息，加级别加工资
#         employee_info_dist["级别"] = 2
#         employee_info_dist["工资"] += 1000
#         # 把员工信息更新会info_list
#         info_dict[name] = employee_info_dist
#
# # 输出结果
# print(f"对员工进行升级加薪后的结果是：{info_dict}")

# """
# 演示数据容器的通用功能
# """
# my_list = [1, 2, 3, 4, 5]
# my_tuple = (1, 2, 3, 4, 5)
# my_str = "abcdefg"
# my_set = {1, 2, 3, 4, 5}
# my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}
# # len元素个数
# print(f"列表 元素个数有：{len(my_list)}")
# print(f"元组 元素个数有：{len(my_tuple)}")
# print(f"字符串元素个数有：{len(my_str)}")
# print(f"集合 元素个数有：{len(my_set)}")
# print(f"字典 元素个数有：{len(my_dict)}")
# # max最大元素
# print(f"列表 最大的元素是：{max(my_list)}")
# print(f"元组 最大的元素是：{max(my_tuple)}")
# print(f"字符串最大的元素是：{max(my_str)}")
# print(f"集合 最大的元素是：{max(my_set)}")
# print(f"字典 最大的元素是：{max(my_dict)}")
# # min最小元素
# print(f"列表 最小的元素是：{min(my_list)}")
# print(f"元组 最小的元素是：{min(my_tuple)}")
# print(f"字符串最小的元素是：{min(my_str)}")
# print(f"集合 最小的元素是：{min(my_set)}")
# print(f"字典 最小的元素是：{min(my_dict)}")
# # 类型转换: 容器转列表
# print(f"列表转列表的结果是：{list(my_list)}")
# print(f"元组转列表的结果是：{list(my_tuple)}")
# print(f"字符串转列表结果是：{list(my_str)}")
# print(f"集合转列表的结果是：{list(my_set)}")
# print(f"字典转列表的结果是：{list(my_dict)}")
# # 类型转换: 容器转元组
# print(f"列表转元组的结果是：{tuple(my_list)}")
# print(f"元组转元组的结果是：{tuple(my_tuple)}")
# print(f"字符串转元组结果是：{tuple(my_str)}")
# print(f"集合转元组的结果是：{tuple(my_set)}")
# print(f"字典转元组的结果是：{tuple(my_dict)}")
# # 类型转换: 容器转字符串
# print(f"列表转字符串的结果是：{str(my_list)}")
# print(f"元组转字符串的结果是：{str(my_tuple)}")
# print(f"字符串转字符串结果是：{str(my_str)}")
# print(f"集合转字符串的结果是：{str(my_set)}")
# print(f"字典转字符串的结果是：{str(my_dict)}")
# # 类型转换: 容器转集合
# print(f"列表转集合的结果是：{set(my_list)}")
# print(f"元组转集合的结果是：{set(my_tuple)}")
# print(f"字符串转集合结果是：{set(my_str)}")
# print(f"集合转集合的结果是：{set(my_set)}")
# print(f"字典转集合的结果是：{set(my_dict)}")
# 进行容器的排序
# my_list = [3, 1, 2, 5, 4]
# my_tuple = (3, 1, 2, 5, 4)
# my_str = "bdcefga"
# my_set = {3, 1, 2, 5, 4}
# my_dict = {"key3": 1, "key1": 2, "key2": 3, "key5": 4, "key4": 5}
# print(f"列表对象的排序结果：{sorted(my_list)}")
# print(f"元组对象的排序结果：{sorted(my_tuple)}")
# print(f"字符串对象的排序结果：{sorted(my_str)}")
# print(f"集合对象的排序结果：{sorted(my_set)}")
# print(f"字典对象的排序结果：{sorted(my_dict)}")
#
# print(f"列表对象的反向排序结果：{sorted(my_list, reverse=True)}")
# print(f"元组对象的反向排序结果：{sorted(my_tuple, reverse=True)}")
# print(f"字符串对象反向的排序结果：{sorted(my_str, reverse=True)}")
# print(f"集合对象的反向排序结果：{sorted(my_set, reverse=True)}")
# print(f"字典对象的反向排序结果：{sorted(my_dict, reverse=True)}")

# """
# 演示字符串大小比较
# """

# abc 比较 abd
print(f"adb大于abc，结果：{'adb' > 'abc'}")
# a 比较 ab
print(f"ad大于a，结果：{'ad' > 'a'}")
# a 比较 A
print(f"a大于A，结果：{'a' > 'A'}")
# key1 比较 key2
print(f"key2 > key1,结果：{'key2' > 'key1'}")
